const connection = require("../../config/mysql.js");

/**
 * 添加标签
 * @param {*} ctx - Koa 的上下文对象
 */
const addLabel = async (ctx) => {
    const { label_name, color } = ctx.request.body;

    // 校验必填字段
    if (!label_name) {
        ctx.status = 400;
        ctx.body = { code: 0, msg: '缺少 label_name' }; // 之前只返回了字段名，建议提示更清晰
        return;
    }

    try {
        // 1. 查询是否已存在相同 label_name
        const [existingRows] = await connection.query(
            'SELECT * FROM label WHERE label_name = ?',
            [label_name]
        );

        if (existingRows.length > 0) {
            ctx.status = 400;
            ctx.body = { code: 0, msg: 'label 已存在' };
            return;
        }

        // 2. 插入新标签
        const [insertResult] = await connection.query(
            'INSERT INTO label (label_name, color) VALUES (?, ?)',
            [label_name, color || ''] // 默认颜色可为空，或设置默认值
        );

        ctx.status = 200;
        ctx.body = {
            code: 1,
            msg: '添加成功',
            data: insertResult,
        };

    } catch (err) {
        console.error('添加标签失败:', err);
        ctx.status = 500;
        ctx.body = { code: 0, msg: '服务器错误' };
    }
};
/**
 * 添加标签
 * @param {*} ctx - Koa 的上下文对象
 */
const addStateLabel = async (ctx) => {
    const { label_name, color } = ctx.request.body;

    // 校验必填字段
    if (!label_name) {
        ctx.status = 400;
        ctx.body = { code: 0, msg: '缺少 label_name' }; // 之前只返回了字段名，建议提示更清晰
        return;
    }

    try {
        // 1. 查询是否已存在相同 label_name
        const [existingRows] = await connection.query(
            'SELECT * FROM state_label WHERE label_name = ?',
            [label_name]
        );

        if (existingRows.length > 0) {
            ctx.status = 400;
            ctx.body = { code: 0, msg: 'label 已存在' };
            return;
        }

        // 2. 插入新标签
        const [insertResult] = await connection.query(
            'INSERT INTO state_label (label_name, color) VALUES (?, ?)',
            [label_name, color || ''] // 默认颜色可为空，或设置默认值
        );

        ctx.status = 200;
        ctx.body = {
            code: 1,
            msg: '添加成功',
            data: insertResult,
        };

    } catch (err) {
        console.error('添加标签失败:', err);
        ctx.status = 500;
        ctx.body = { code: 0, msg: '服务器错误' };
    }
};
/**
 * 获取所有状态标签
 * @param {*} ctx 
 */
const getStateLabels = async (ctx) => {
    try {
        const [rows] = await connection.query('SELECT * FROM state_label');

        ctx.status = 200;
        ctx.body = {
            code: 1,
            msg: '获取成功',
            data: rows,
        };

    } catch (err) {
        console.error('获取标签失败:', err);
        ctx.status = 500;
        ctx.body = { code: 0, msg: '服务器错误' };
    }
};
/**
 * 获取所有标签
 * @param {*} ctx 
 */
const getLabels = async (ctx) => {
    try {
        const [rows] = await connection.query('SELECT * FROM label');

        ctx.status = 200;
        ctx.body = {
            code: 1,
            msg: '获取成功',
            data: rows,
        };

    } catch (err) {
        console.error('获取标签失败:', err);
        ctx.status = 500;
        ctx.body = { code: 0, msg: '服务器错误' };
    }
};
/**
 * 删除标签
 * @param {*} ctx 
 */
const deleteLabel = async (ctx) => {
    const { label_id } = ctx.request.body;

    if (!label_id) {
        ctx.status = 400;
        ctx.body = { code: 0, msg: '缺少 label_id' };
        return;
    }

    try {
        // 1. 检查 multi_label 表中是否有使用该标签
        const [usedRows] = await connection.query(
            'SELECT * FROM multi_label WHERE labelid = ?',
            [label_id]
        );

        if (usedRows.length > 0) {
            ctx.status = 200;
            ctx.body = {
                code: 1,
                msg: '该类型的标签正在被使用，无法删除，请确保没有任何资源被标注为该类型',
            };
            return;
        }

        // 2. 执行删除
        const [deleteResult] = await connection.query(
            'DELETE FROM label WHERE label_id = ?',
            [label_id]
        );
        if (deleteResult.affectedRows === 0) {
            ctx.status = 404;
            ctx.body = { code: 0, msg: '未找到该标签或已删除' };
            return;
        }
        ctx.status = 200;
        ctx.body = {
            code: 1,
            msg: '删除成功',
            data: deleteResult,
        };

    } catch (err) {
        console.error('删除标签失败:', err);
        ctx.status = 500;
        ctx.body = { code: 0, msg: '服务器错误' };
    }
};
/**
 * 删除状态标签
 * @param {*} ctx 
 */
const deleteStateLabel = async (ctx) => {
    const { label_id } = ctx.request.body;
    if (label_id == 1) {
        ctx.status = 200;
        ctx.body = {
            code: 0,
            msg: '默认标签无法删除',
        };
        return;
    }
    if (label_id == 0) {
        ctx.status = 200;
        ctx.body = {
            code: 0,
            msg: '已删除标签无法删除',
        };
        return;
    }
    if (!label_id) {
        ctx.status = 400;
        ctx.body = { code: 0, msg: '缺少 label_id' };
        return;
    }

    try {
        // 1. 检查 multi_label 表中是否有使用该标签
        const [usedRows] = await connection.query(
            'SELECT * FROM multi_label WHERE state = ?',
            [label_id]
        );

        if (usedRows.length > 0) {
            ctx.status = 200;
            ctx.body = {
                code: 1,
                msg: '该类型的标签正在被使用，无法删除，请确保没有任何资源使用此标签',
            };
            return;
        }

        // 2. 执行删除
        const [deleteResult] = await connection.query(
            'DELETE FROM state_label WHERE label_id = ?',
            [label_id]
        );
        if (deleteResult.affectedRows === 0) {
            ctx.status = 404;
            ctx.body = { code: 0, msg: '未找到该标签或已删除' };
            return;
        }
        ctx.status = 200;
        ctx.body = {
            code: 1,
            msg: '删除成功',
            data: deleteResult,
        };

    } catch (err) {
        console.error('删除标签失败:', err);
        ctx.status = 500;
        ctx.body = { code: 0, msg: '服务器错误' };
    }
};

/** multi_label添加数据 */
const addMultiLabel = async (ctx) => {
    const { id, imageName, imageUrl, imageIndicia, labelid, remarks,state } = ctx.request.body;

    if (!imageName || !imageUrl || !labelid) {
        ctx.status = 400;
        ctx.body = { code: 0, msg: '缺少必要参数: imageName, imageUrl, labelid' };
        return;
    }

    try {
        if (id) {
            // 如果传了 id，则认为是更新操作
            // 先检查该 id 是否存在
            const [existingRows] = await connection.query(
                `SELECT * FROM multi_label WHERE id = ?`,
                [id]
            );

            if (existingRows.length === 0) {
                ctx.status = 404;
                ctx.body = { code: 0, msg: '要更新的记录不存在' };
                return;
            }

            // 执行更新
            await connection.query(
                `UPDATE multi_label 
             SET imageName = ?, imageUrl = ?, imageIndicia = ?, labelid = ?, remarks = ? , state = ?
             WHERE id = ?`,
                [imageName, imageUrl, imageIndicia, labelid, remarks,state, id]
            );
        } else {
            // 如果没传 id，则认为是新增操作
            await connection.query(
                `INSERT INTO multi_label (imageName, imageUrl, imageIndicia, labelid, remarks) 
             VALUES (?, ?, ?, ?, ?)`,
                [imageName, imageUrl, imageIndicia, labelid, remarks]
            );
        }

        // 无论新增还是更新，都更新 images 表中对应 imageUrl 的 status 为 2
        await connection.query(
            `UPDATE images SET status = 2 WHERE image_path = ?`,
            [imageUrl]
        );

        ctx.status = 200;
        ctx.body = { code: 1, msg: id ? '更新成功' : '添加成功' };

    } catch (err) {
        console.error('标签操作失败:', err);
        ctx.status = 500;
        ctx.body = { code: 0, msg: '服务器错误' };
    }
}
// 根据imageName获取对应的标签
const getMultiLabelByImageName = async (ctx) => {
    const { imageUrl } = ctx.request.body;
    if (!imageUrl) {
        ctx.status = 400;
        ctx.body = { code: 0, msg: '缺少必要参数' };
        return;
    }
    try {
        const [rows] = await connection.query(`SELECT * FROM multi_label WHERE imageUrl = ? And state > 0`, [imageUrl])
        ctx.status = 200;
        ctx.body = { code: 1, msg: '获取成功', data: rows }
    }
    catch (err) {
        console.error('获取标签失败:', err);
        ctx.status = 500;
        ctx.body = { code: 0, msg: '服务器错误' };
    }
}

/** 删除标签 */
const deleteMultiLabel = async (ctx) => {
    const { id } = ctx.request.body;
    if (!id) {
        ctx.status = 400;
        ctx.body = { code: 0, msg: '缺少必要参数' };
        return;
    }
    // 判断标签状态是否为1，为1才可以进行删除（采用逻辑删除直接把状态改为0即删除）
    try {

        const [rows] = await connection.query(`SELECT * FROM multi_label WHERE id = ?`, [id])
        if (rows.length > 0) {
            await connection.query(`UPDATE multi_label SET state = 0 WHERE id = ?`, [id])
            ctx.status = 200;
            ctx.body = { code: 1, msg: '删除成功' }
        } else {
            ctx.status = 404;
            ctx.body = { code: 0, msg: '未找到该标签' }
        }
    }
    catch (err) {
        console.error('删除标签失败:', err);
        ctx.status = 500;
        ctx.body = { code: 0, msg: '服务器错误' };
    }
}


/** 根据标签类型获取标签列表（带分页和总数） */
const getMultiLabelList = async (ctx) => {
    // 从请求参数中获取
    const labelid = ctx.query.labelid;
    const pageStr = ctx.query.page || '1';
    const pageSizeStr = ctx.query.pageSize || '10';

    // 参数校验与转换：确保 page 和 pageSize 是正整数
    const page = Math.max(1, parseInt(pageStr) || 1); // 最小为第1页
    const pageSize = Math.max(1, parseInt(pageSizeStr) || 10); // 最小为每页1条

    // 计算分页偏移量
    const offset = (page - 1) * pageSize;

    try {
        // 1. 查询当前页数据
        const [rows] = await connection.query(
            `SELECT * FROM multi_label 
             WHERE labelid = ? AND state > 0 
             LIMIT ?, ?`,
            [labelid, offset, pageSize]
        );

        // 2. 查询符合条件的总条数（用于分页信息）
        const [countResult] = await connection.query(
            `SELECT COUNT(*) AS total FROM multi_label 
             WHERE labelid = ? AND state > 0`,
            [labelid]
        );

        const total = parseInt(countResult[0]?.total) || 0;

        // 3. 计算总页数（可选，前端也可以自己算）
        const totalPages = Math.ceil(total / pageSize);

        // 4. 返回成功响应，包含数据、分页信息
        ctx.status = 200;
        ctx.body = {
            code: 1,
            msg: '获取成功',
            data: rows, // 当前页数据
            pagination: {
                page,           // 当前页码
                pageSize,       // 每页条数
                total,          // 总条数
                totalPages,     // 总页数（可选）
            }
        };

    } catch (err) {
        console.error('获取标签失败:', err);
        ctx.status = 500;
        ctx.body = {
            code: 0,
            msg: '服务器错误',
            error: process.env.NODE_ENV === 'development' ? err.message : undefined // 开发环境返回详细错误
        };
    }
};

module.exports = {
    addLabel,
    getLabels,
    deleteLabel,
    addMultiLabel,
    getMultiLabelByImageName,
    deleteMultiLabel,
    addStateLabel,
    getStateLabels,
    deleteStateLabel,
    getMultiLabelList
};